<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">


<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    
    <title>11. Pipeline &mdash; PowerShell fuer Systemintegratoren</title>
    
    <link rel="stylesheet" href="_static/sphinxdoc.css" type="text/css" />
    <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
    
    <script type="text/javascript">
      var DOCUMENTATION_OPTIONS = {
        URL_ROOT:    './',
        VERSION:     '1.0',
        COLLAPSE_INDEX: false,
        FILE_SUFFIX: '.html',
        HAS_SOURCE:  true
      };
    </script>
    <script type="text/javascript" src="_static/jquery.js"></script>
    <script type="text/javascript" src="_static/underscore.js"></script>
    <script type="text/javascript" src="_static/doctools.js"></script>
    <script type="text/javascript" src="_static/translations.js"></script>
    <link rel="top" title="PowerShell fuer Systemintegratoren" href="index.html" />
    <link rel="next" title="12. Objekte in der PS" href="powershell_customobjects.html" />
    <link rel="prev" title="10. Funktionen" href="powershell_funktionen.html" /> 
  </head>
  <body>
    <div class="related">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="genindex.html" title="Allgemeiner Index"
             accesskey="I">Index</a></li>
        <li class="right" >
          <a href="powershell_customobjects.html" title="12. Objekte in der PS"
             accesskey="N">weiter</a> |</li>
        <li class="right" >
          <a href="powershell_funktionen.html" title="10. Funktionen"
             accesskey="P">zurück</a> |</li>
        <li><a href="index.html">PS4SYS</a> &raquo;</li> 
      </ul>
    </div>
      <div class="sphinxsidebar">
        <div class="sphinxsidebarwrapper">
            <p class="logo"><a href="index.html">
              <img class="logo" src="_static/PowerShell_icon_small.png" alt="Logo"/>
            </a></p>
  <h3><a href="index.html">Inhalt</a></h3>
  <ul>
<li><a class="reference internal" href="#">11. Pipeline</a><ul>
<li><a class="reference internal" href="#streaming-vs-blocking">11.1. Streaming vs Blocking</a></li>
<li><a class="reference internal" href="#eigenschaften-der-objekte">11.2. Eigenschaften der Objekte</a></li>
<li><a class="reference internal" href="#ausgabe">11.3. Ausgabe</a><ul>
<li><a class="reference internal" href="#andern-der-spaltenuberschriften">11.3.1. Ändern der Spaltenüberschriften</a></li>
<li><a class="reference internal" href="#optimieren-der-spaltenbreiten">11.3.2. Optimieren der Spaltenbreiten</a></li>
</ul>
</li>
<li><a class="reference internal" href="#sortieren-und-gruppieren-der-pipeline-ergebnisse">11.4. Sortieren und Gruppieren der Pipeline-Ergebnisse</a><ul>
<li><a class="reference internal" href="#sortieren">11.4.1. Sortieren</a></li>
<li><a class="reference internal" href="#gruppieren">11.4.2. Gruppieren</a></li>
</ul>
</li>
<li><a class="reference internal" href="#filtern">11.5. Filtern</a><ul>
<li><a class="reference internal" href="#begrenzen-der-anzahl-der-ausgabe">11.5.1. Begrenzen der Anzahl der Ausgabe</a></li>
</ul>
</li>
<li><a class="reference internal" href="#foreach-objekt">11.6. Foreach-Objekt</a></li>
<li><a class="reference internal" href="#zwischenergebnisse">11.7. Zwischenergebnisse</a></li>
<li><a class="reference internal" href="#ausgabe-von-pipeline-ergebnissen">11.8. Ausgabe von Pipeline-Ergebnissen</a></li>
<li><a class="reference internal" href="#funktionen-und-pipeline">11.9. Funktionen und Pipeline</a></li>
<li><a class="reference internal" href="#pipeline-oder-schleife">11.10. Pipeline oder Schleife</a></li>
<li><a class="reference internal" href="#pipeline-filter-und-funktionen">11.11. Pipeline/Filter und Funktionen</a><ul>
<li><a class="reference internal" href="#sequentieller-modus">11.11.1. Sequentieller Modus</a></li>
<li><a class="reference internal" href="#filter">11.11.2. Filter</a></li>
<li><a class="reference internal" href="#generische-filter">11.11.3. Generische Filter</a></li>
</ul>
</li>
<li><a class="reference internal" href="#zusammenfassung">11.12. Zusammenfassung</a></li>
<li><a class="reference internal" href="#links">11.13. Links</a></li>
</ul>
</li>
</ul>

  <h4>Vorheriges Thema</h4>
  <p class="topless"><a href="powershell_funktionen.html"
                        title="vorheriges Kapitel">10. Funktionen</a></p>
  <h4>Nächstes Thema</h4>
  <p class="topless"><a href="powershell_customobjects.html"
                        title="nächstes Kapitel">12. Objekte in der PS</a></p>
  <h3>Diese Seite</h3>
  <ul class="this-page-menu">
    <li><a href="_sources/powershell_pipeline.txt"
           rel="nofollow">Quelltext anzeigen</a></li>
  </ul>
<div id="searchbox" style="display: none">
  <h3>Schnellsuche</h3>
    <form class="search" action="search.html" method="get">
      <input type="text" name="q" />
      <input type="submit" value="Los" />
      <input type="hidden" name="check_keywords" value="yes" />
      <input type="hidden" name="area" value="default" />
    </form>
    <p class="searchtip" style="font-size: 90%">
    Geben Sie Suchbegriffe oder einen Modul-, Klassen- oder Funktionsnamen ein.
    </p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
        </div>
      </div>

    <div class="document">
      <div class="documentwrapper">
        <div class="bodywrapper">
          <div class="body">
            
  <div class="section" id="pipeline">
<span id="index-0"></span><h1>11. Pipeline<a class="headerlink" href="#pipeline" title="Permalink zu dieser Überschrift">¶</a></h1>
<p>Die Pipeline verbindet eine Vielzahl von Befehlen zusammen; das Ergebnis eine Befehls wird als Eingabewert fÃ¼r den nÃ¤chsten Befehl verwendet, solange, bis das gewÃ¼nschte Ergebnis erreicht ist.</p>
<p>test</p>
<img alt="_images/pipeline_1.jpg" src="_images/pipeline_1.jpg" />
<img alt="_images/pipeline_2.jpg" src="_images/pipeline_2.jpg" />
<img alt="_images/pipeline_3.jpg" src="_images/pipeline_3.jpg" />
<p>WÃ¤hrend es auch schon zu DOS-Zeiten das Konzept des Pipens gab und auch Unix-Shells heftig davon Gebrauch machen, gibt es doch einen gravierenden Unterschied zu diesen alten Implementierungen. WÃ¤hrend in der alten Zeit Strings als Tauschformat benutzt wurden, verwendet die Powershell echte Objekte. Die Eigenschaften und Methoden der transportierten Objekte bleiben dabei erhalten.</p>
<div class="highlight-sh"><div class="highlight"><pre>Dir | Sort-Object Length | Select-Object Name, Length |
ConvertTo-Html | Out-File report.htm
.<span class="se">\r</span>eport.htm
</pre></div>
</div>
<p>Bis zuletzt bleiben die Ergebnisse Objekte, von denen relativ leicht bestimmte Eigenschaften (Name, Length) ausgegeben werden kÃƒÂ¶nnen</p>
<div class="topic">
<p class="topic-title first">Zitat</p>
<p>&#8220;What you see here is a true object-oriented pipeline so the results from a command remain rich objects. Only at the end of the pipeline will the results be reduced to text or HTML or whatever you choose for output. Take a look at Sort-Object. It sorts the directory listing by file size. If the pipeline had simply fed plain text into Sort-Object, you would have had to tell Sort-Object just where the file size information was to be found in the raw text. You would also have had to tell Sort-Object to sort this information numerically and not alphabetically.</p>
<p>Not so here. All you need to do is tell Sort-Object which object property you want to sort. The object nature tells Sort-Object all it needs to know: where the information you want to sort is found, and whether it is numeric or letters.</p>
<p>You only have to tell Sort-Object which object property to use for sorting because PowerShell sends results as rich .NET objects through the pipeline. Sort-Object does all the rest automatically. Simply replace Length with another object property, such as Name or LastWriteTime, to sort according to these criteria. Unlike text, information in an object is clearly structured: this is a crucial PowerShell pipeline advantage.&#8221;</p>
</div>
<p><strong>Aufgabe</strong>: ÃƒÅ“bersetzen Sie den englischen Text sinngemÃƒÂ¤ÃƒÅ¸.</p>
<div class="sidebar">
<p class="first sidebar-title">ÃƒÅ“bersetzung</p>
<p class="last">SinngemÃƒÂ¤ÃƒÅ¸ in die deutsche Sprache</p>
</div>
<a class="reference external image-reference" href="_images/notizzettel.png"><img alt="alternate text" class="align-left" src="_images/notizzettel.png" style="width: 50px;" /></a>
<p id="index-1">Das Konzept der Pipeline wird auf alle Ausgaben angewendet, auch wenn dies nicht immer explizit zu erkennen ist.  Auf alle Ausgaben wid das Out-Default-Cmdlet hinzugefÃƒÂ¼gt, welches die Ausgabe in Textform bewirkt</p>
<p>Ein DIR ist damit eigentlich ein DIR | Out-Default.</p>
<p>Folgende Cmdlets stehen zur VerfÃƒÂ¼gung.</p>
<img alt="_images/pipeline_cmdlet_1.png" src="_images/pipeline_cmdlet_1.png" />
<img alt="_images/pipeline_cmdlet_2.png" src="_images/pipeline_cmdlet_2.png" />
<img alt="_images/pipeline_cmdlet_3.png" src="_images/pipeline_cmdlet_3.png" />
<img alt="_images/pipeline_cmdlet_4.png" src="_images/pipeline_cmdlet_4.png" />
<img alt="_images/pipeline_cmdlet_5.png" src="_images/pipeline_cmdlet_5.png" />
<span class="target" id="index-2"></span><div class="section" id="streaming-vs-blocking">
<span id="index-3"></span><h2>11.1. Streaming vs Blocking<a class="headerlink" href="#streaming-vs-blocking" title="Permalink zu dieser Überschrift">¶</a></h2>
<p>Bei der Kombination per Pipeline kommt schnell die Frage auf, wann denn jetzt ein einzelner Befehl tatsÃƒÂ¤chlich umgesetzt wird. Dies hÃƒÂ¤ngt vom jeweiligen Modus ab, in dem die Pipeline arbeitet.</p>
<p id="index-4"><em>Sequentieller Modus:</em></p>
<blockquote>
<div><p>In diesem Modus werden die Befehle streng hintereinander ausgeführt, d.h. die Eregbnisse werden erst dann per Pipeline weitergereicht, wenn es komplett berechnet ist. Dieser Modus ist langsam und speicherintensiv, lässt sich aber nicht immer vermeiden, z.B. beim Sort-Object-Cmdlet. So sind im unteren Beispiel die ersten beiden Pipeline sequentiell, während das 3. Beispiel streaming-fähig ist.</p>
<div class="highlight-sh"><div class="highlight"><pre><span class="c"># Attention: danger!</span>
Dir C:<span class="se">\ </span>-recurse | Sort-Object

Dir C:<span class="se">\ </span>-recurse | more

Dir c:<span class="se">\ </span>-recurse | Out-Host -paging
</pre></div>
</div>
</div></blockquote>
<p id="index-5"><em>Streaming Modus:</em></p>
<blockquote>
<div>Hier wird jedes einzelne Ergebnis einer Berechnung sofort an den nächsten Befehl weitergereicht</div></blockquote>
<div class="sidebar">
<p class="first sidebar-title">Tafelbild</p>
<p class="last">Streaming vs Blocking</p>
</div>
<a class="reference external image-reference" href="_images/notizzettel.png"><img alt="alternate text" class="align-left" src="_images/notizzettel.png" style="width: 50px;" /></a>
</div>
<div class="section" id="eigenschaften-der-objekte">
<h2>11.2. Eigenschaften der Objekte<a class="headerlink" href="#eigenschaften-der-objekte" title="Permalink zu dieser Überschrift">¶</a></h2>
<p>Um nicht nur die Standard-Eigenschaften der Objekte zu sehen, kann man sich mit Hilfe Format-Cmdlets einen Überblick über die Eigenschaften geben.</p>
<div class="highlight-sh" id="index-6"><div class="highlight"><pre>Dir | Format-Table *

Dir | Format-List *
</pre></div>
</div>
<p>Die Darstellung der Ausgabe kann mit Hilfe von 4 Format-Cmdlets erfolgen:</p>
<div class="highlight-sh"><div class="highlight"><pre>Get-Command -verb format
CommandType
-----------
Cmdlet
Cmdlet
Cmdlet
Cmdlet
Name
----
Format-Custom
Format-List
Format-Table
Format-Wide
Definition
----------
Format-Custom <span class="o">[[</span>-Property<span class="o">]</span> &lt;Objec...
Format-List <span class="o">[[</span>-Property<span class="o">]</span> &lt;Object<span class="o">[</span>...
Format-Table <span class="o">[[</span>-Property<span class="o">]</span> &lt;Object...
Format-Wide <span class="o">[[</span>-Property<span class="o">]</span> &lt;Object&gt;...
</pre></div>
</div>
</div>
<div class="section" id="ausgabe">
<h2>11.3. Ausgabe<a class="headerlink" href="#ausgabe" title="Permalink zu dieser Überschrift">¶</a></h2>
<p>Die Ausgabe spezieller Eigenschaften erfolgt dann durch Hintereinanderstellen der jeweiligen Namen. Wildcards sind erlaubt.</p>
<img alt="_images/pipeline_format_table.png" src="_images/pipeline_format_table.png" />
<div class="highlight-sh"><div class="highlight"><pre>Get-Process i* | Format-Table name,pe*64
</pre></div>
</div>
<img alt="_images/pipeline_format_table_2.png" src="_images/pipeline_format_table_2.png" />
<p>Skriptblöcke und künstliche Eigenschaften sind ebenso möglich:
Im unteren Beispiel ist $_ jeweils das aktuelle Objekt in der Pipeline.</p>
<div class="highlight-sh"><div class="highlight"><pre>Dir | Format-Table Name, <span class="o">{</span> <span class="o">[</span>int<span class="o">](</span><span class="nv">$_</span>.Length/1KB<span class="o">)</span> <span class="o">}</span>

PS C:<span class="se">\t</span>emp&gt; Dir | Format-Table Name, <span class="o">{</span> <span class="o">[</span>int<span class="o">](</span><span class="nv">$_</span>.Length/1KB<span class="o">)</span> <span class="o">}</span>

Name                                      <span class="o">[</span>int<span class="o">](</span><span class="nv">$_</span>.Length/1KB<span class="o">)</span>
----                                      ----------------------
FirefoxPortable                              0
postkarten                                   0
Ausgabe.txt                                  3
autorun.inf                                  0
index.html                                   4
index_haas.html                              3
ShelExec.exe                                60
Zeungnisbemerkung_11FI2_2009                 3
</pre></div>
</div>
<p>Oder man möchte wissen, wie alt die Dateien seit der letzten Veränderung sind. Dies liefert uns die Kombination der folgenden Befehle:</p>
<div class="highlight-sh"><div class="highlight"><pre>New-TimeSpan <span class="s2">&quot;01/01/2000&quot;</span> <span class="o">(</span>Get-Date<span class="o">)</span> //Zeitdifferenz zwischen heute und dem 1.1.2000

<span class="c"># gibt uns die Zeitdifferenz zwischen Heute und dem letzten Zugriff des jeweiligen Objektes</span>
<span class="o">{(</span>New-TimeSpan <span class="nv">$_</span>.LastWriteTime <span class="o">(</span>Get-Date<span class="o">))</span>.Days<span class="o">}</span>


<span class="c"># kombiniert alles zu einer schÃƒÆ’Ã†â€™Ãƒâ€šÃ‚Â¶nen Pipeline</span>
Dir | Format-Table Name, Length, <span class="o">{(</span>New-TimeSpan <span class="nv">$_</span>.LastWriteTime <span class="o">(</span>Get-Date<span class="o">))</span>.Days<span class="o">}</span> -autosize
</pre></div>
</div>
<img alt="_images/pipeline_format_table_3.png" src="_images/pipeline_format_table_3.png" />
<div class="section" id="andern-der-spaltenuberschriften">
<h3>11.3.1. Ändern der Spaltenüberschriften<a class="headerlink" href="#andern-der-spaltenuberschriften" title="Permalink zu dieser Überschrift">¶</a></h3>
<p>Die Spaltenüberschriften könhen geändert werden, wenn auch etwas umständlich</p>
<p>Dir | Format-Table Name, &#64;{Label=&#8221;Größe&#8221;; Expression={([int]($_.Length/1KB))}} -AutoSize</p>
<p>Dir | Format-Table Name, Length, &#64;{Label=&#8221;Differenz&#8221;; Expression ={(New-TimeSpan $_.LastWriteTime (Get-Date)).Days}} -autosize</p>
<p>Dir | Format-Table Name, Length, &#64;{Label=&#8221;Länge&#8221;; Expression ={$_.Length}} -autosize</p>
</div>
<div class="section" id="optimieren-der-spaltenbreiten">
<h3>11.3.2. Optimieren der Spaltenbreiten<a class="headerlink" href="#optimieren-der-spaltenbreiten" title="Permalink zu dieser Überschrift">¶</a></h3>
<p>Wegen der Echtzeitausgabe kann Format-Table nicht wissen, wie breit eine Spalte zu wählen ist, um eine optimale Anzeige aller Werte zu erhalten. Man kann dies durch die Option <strong>-auto</strong> erhalten, verliert aber damit den Vorteil der Echtzeit.</p>
<div class="highlight-sh"><div class="highlight"><pre><span class="nv">column</span> <span class="o">=</span> @<span class="o">{</span><span class="nv">Expression</span><span class="o">={</span> <span class="o">[</span>int<span class="o">](</span><span class="nv">$_</span>.Length/1KB<span class="o">)</span> <span class="o">}</span>; <span class="nv">Label</span><span class="o">=</span><span class="s2">&quot;KB&quot;</span> <span class="o">}</span>
Dir | Format-Table Name, <span class="nv">$column</span> -auto
Name
----
output.htm
output.txt
backup.pfx
cmdlet.txt
KB
--
11
13
2
23
</pre></div>
</div>
</div>
</div>
<div class="section" id="sortieren-und-gruppieren-der-pipeline-ergebnisse">
<h2>11.4. Sortieren und Gruppieren der Pipeline-Ergebnisse<a class="headerlink" href="#sortieren-und-gruppieren-der-pipeline-ergebnisse" title="Permalink zu dieser Überschrift">¶</a></h2>
<div class="admonition note">
<p class="first admonition-title">Bemerkung</p>
<p>So that you can make good use of Sort-Object and all the other following cmdlets, you must also know which properties are available for the objects traveling through the pipeline. In the last section, you learned how to do that. Send the result of Dir to Format-List * first, then you&#8217;ll see all properties and you can select one to use for subsequent sorting:</p>
<p class="last">Dir | Format-List *</p>
</div>
<div class="section" id="sortieren">
<span id="index-7"></span><h3>11.4.1. Sortieren<a class="headerlink" href="#sortieren" title="Permalink zu dieser Überschrift">¶</a></h3>
<p>Das Sortierung erfolgt mit Hilfe des Sort-Object-Cmdlets. Falls nichts angegeben wird, sucht sich das Sort-Object-Cmdlet seine eigene Property zum Sortieren.</p>
<div class="highlight-sh"><div class="highlight"><pre>Dir | Sort-Object
</pre></div>
</div>
<p>Eigene Sortierkriterien übergibt man mit der Property-Eigenschaft.</p>
<div class="highlight-sh"><div class="highlight"><pre>Dir  | Sort-Object -property Length -descending

Dir | Sort-Object Extension, Name

Dir | Sort-Object Extension, Name -descending

<span class="c">#das geht nicht</span>
Dir | Sort-Object Extension, Name -descending, -ascending

<span class="c">#wir müssen es an eine hash-table übergeben</span>
Dir | Sort-Object @<span class="o">{</span><span class="nv">expression</span><span class="o">=</span><span class="s2">&quot;Length&quot;</span>;<span class="nv">Descending</span><span class="o">=</span><span class="nv">$true</span><span class="o">}</span>, @<span class="o">{</span><span class="nv">expression</span><span class="o">=</span><span class="s2">&quot;Name&quot;</span>;<span class="nv">Ascending</span><span class="o">=</span><span class="nv">$true</span><span class="o">}</span>
</pre></div>
</div>
<img alt="_images/pipeline_sort_object_many.jpg" src="_images/pipeline_sort_object_many.jpg" />
<div class="sidebar">
<p class="first sidebar-title">Tafelbild</p>
<p class="last">Sortieren als Blocker</p>
</div>
<a class="reference external image-reference" href="_images/notizzettel.png"><img alt="alternate text" class="align-left" src="_images/notizzettel.png" style="width: 50px;" /></a>
</div>
<div class="section" id="gruppieren">
<span id="index-8"></span><h3>11.4.2. Gruppieren<a class="headerlink" href="#gruppieren" title="Permalink zu dieser Überschrift">¶</a></h3>
<p>Mit Hilfe des Group-Object_Cmdlets können Sie Objekte mit gleichen Eigenschaften nach Ihrer Anzahl gruppieren.</p>
<p>Das folgende Beispiel gibt die Anzahl der laufenden und gestoppten Dienste zurück.</p>
<div class="highlight-sh"><div class="highlight"><pre>Get-Service | Group-Object Status
</pre></div>
</div>
<img alt="_images/pipeline_group_object.jpg" src="_images/pipeline_group_object.jpg" />
<div class="highlight-sh"><div class="highlight"><pre>    <span class="nv">$result</span> <span class="o">=</span> Get-Service | Group-Object Status
    <span class="nv">$result</span><span class="o">[</span>0<span class="o">]</span>.Group

    Dir | Group-Object Extension

    Dir | Group-Object Extension | Sort-Object Count -descending

    Count Name                      Group
    ----- ----                      -----
26                           <span class="o">{</span>data, docbook, Documents, Dokumente und Ein...
18 .log                      <span class="o">{</span>start.log, 20100318180017.log, Ve...
     9 .txt                      <span class="o">{</span>ctapi_out_gr.txt, Ergebnis3.txt, ergebnisne...
     5 .pdf                      <span class="o">{</span>AbschlussprÃƒÆ’Ã†â€™Ãƒâ€šÃ‚Â¼fung Winter 2002 - 2003.pdf, an...
     5 .jpg                      <span class="o">{</span>last.jpg, presse_1.jpg, presse_2.jpg, press...
     2 .out                      <span class="o">{</span>err.out, start.out<span class="o">}</span>
     2 .zip                      <span class="o">{</span>dvd_postkarten_16052010.zip, Stoffverteilun...
     2 .tex                      <span class="o">{</span>start.tex, syntax.tex<span class="o">}</span>
     2 .GDB                      <span class="o">{</span>TEST10.GDB, TEST9.GDB<span class="o">}</span>
     1 .hnd                      <span class="o">{</span>sf.hnd<span class="o">}</span>
     1 .ods                      <span class="o">{</span>schueler.ods<span class="o">}</span>
</pre></div>
</div>
<p>Group-Object kann nicht nur nach Eigenschaften gruppieren, sondern auch nach eigenen Ausdrücken. Das folgende Beispiel gruppiert alle Dateien, in AbhÃƒÂ¤ngigkeit, ob sie größer als 100 kByte oder kleiner sind.</p>
<div class="highlight-sh"><div class="highlight"><pre>PS C:<span class="se">\&gt;</span> Dir | Group-Object <span class="o">{</span><span class="nv">$_</span>.Length -gt 100KB<span class="o">}</span>

Count Name                      Group
----- ----                      -----
78 False                     <span class="o">{</span>cruisecontrol-bin-2.8.3, data, docbook, Doc...
23 True                      <span class="o">{</span>Abschlussprüfung Winter 2002 - 2003.pdf, dv...
</pre></div>
</div>
<p>Das folgende Beispiel gruppiert nach der Anzahl des Vorkommens des jeweils 1. Buchstabens.</p>
<div class="highlight-sh"><div class="highlight"><pre> PS C:<span class="se">\&gt;</span> Dir | Group-Object <span class="o">{</span><span class="nv">$_</span>.name.SubString<span class="o">(</span>0,1<span class="o">)</span>.toUpper<span class="o">()}</span>

 Count Name          Group
 ----- ----          -----
 3       C           <span class="o">{</span>cruisecontrol-bin-2.8.3, config.sys, ctapi_...
10       D           <span class="o">{</span>data, docbook, Documents, Dokumente und Ein...
 3       I           <span class="o">{</span>inetpub, Intel, ihk_pruefung.pdf<span class="o">}</span>
 4       M           <span class="o">{</span>Miranda IM, music, mymiktex, myPass.kdbx<span class="o">}</span>
10       P           <span class="o">{</span>PerfLogs, Program Files, ProgramData, Progr...
 1       R           <span class="o">{</span>RavenDB-Build-101<span class="o">}</span>
13       S           <span class="o">{</span>Sounds, steinam, schueler.ods, sf.hnd...<span class="o">}</span>
 8       T           <span class="o">{</span>TEMP, totalcmd, test.ps1, TEST10.GDB...<span class="o">}</span>
 1       U           <span class="o">{</span>Users<span class="o">}</span>
 3       W           <span class="o">{</span>Windows, WiresharkPortable, wepkeys.txt<span class="o">}</span>
 2       .           <span class="o">{</span>.emacs, .emacs~<span class="o">}</span>
 5       A           <span class="o">{</span>Abschlussprüfung Winter 2002 - 2003.pdf, Ak...
 3       E           <span class="o">{</span>Ergebnis3.txt, ergebnisnew.txt, err.out<span class="o">}</span>
 2       H           <span class="o">{</span>haas.txt, haas_lanig.txt<span class="o">}</span>
 1       K           <span class="o">{</span>KOS_09_10.dav<span class="o">}</span>
 4       L           <span class="o">{</span>last.jpg, LA_ansichten_booklet <span class="o">(</span>2<span class="o">)</span>.pdf, LA_...
</pre></div>
</div>
<p>Wie man sieht, ist jede Zeile ein eigener Array mit allen Objekten der jeweiligen Gruppierung. Man könnte dies nutzen, um eine alphabetische Liste aller Objekte auszugeben.</p>
<div class="highlight-sh"><div class="highlight"><pre>    Dir | Group-Object <span class="o">{</span><span class="nv">$_</span>.name.SubString<span class="o">(</span>0,1<span class="o">)</span>.toUpper<span class="o">()}</span> | ForEach-Object <span class="o">{</span> <span class="o">(</span><span class="nv">$_</span>.Name<span class="o">)</span>*7; <span class="s2">&quot;=======&quot;</span>; <span class="nv">$_</span>.Group<span class="o">}</span>

<span class="nv">CCCCCCC</span>
<span class="o">=======</span>

Verzeichnis: C:<span class="se">\</span>

    Mode                LastWriteTime     Length Name
    ----                -------------     ------ ----
    d----        06.06.2010     21:22            cruisecontrol-bin-2.8.3
    -a---        10.06.2009     23:42         10 config.sys
    -a---        01.04.2010     22:23          0 ctapi_out_gr.txt
    <span class="nv">DDDDDDD</span>
    <span class="o">=======</span>
    d----        20.07.2010     23:00            data
    d----        21.08.2009     22:24            docbook
    d----        25.07.2010     20:28            Documents
    d----        31.07.2009     22:40            Dokumente und Einstellungen
    d----        24.02.2010     08:58            download
    d----        20.05.2010     18:09            dvd_postkarten_16052010
    -a---        23.11.2009     21:27        264 dfsd.nsd
    -a---        18.12.2009     21:20       7737 dienste.htm
    -a---        16.05.2010     20:30       1665 dsd.aup
    -a---        10.06.2010     08:30  289840446 dvd_postkarten_16052010.zip
    <span class="nv">IIIIIII</span>
    <span class="o">=======</span>
    d----        18.08.2009     20:54            inetpub
    d----        18.08.2009     09:27            Intel
    -a---        02.08.2009     21:35     165025 ihk_pruefung.pdf
    MMMMMMM
</pre></div>
</div>
<p id="index-9">Wenn man die gruppierten Objekte selbst nicht benötigt, kann man mit Hilfe des <strong>-noelement</strong>-Parameters Speicher sparen.</p>
<div class="highlight-sh"><div class="highlight"><pre>Get-Process | Group-Object -property Company -noelement

Count Name
----- ----
        2 Apple Inc.
        4
        5
        1 AVerMedia TECHNOLOGIES...
        1 AVerMedia
        3 Avira GmbH
   32 Microsoft Corporation
        2 Firebird Project
        1 Google
        1 Google Inc.
        4 Intel Corporation
        1 Irfan Skiljan
        2 Sun Microsystems, Inc.
        1 Tracker Software Produ...
        1 C. Ghisler &amp; Co.
        1 http://tortoisesvn.net
</pre></div>
</div>
<span class="target" id="index-10"></span></div>
</div>
<div class="section" id="filtern">
<span id="index-11"></span><h2>11.5. Filtern<a class="headerlink" href="#filtern" title="Permalink zu dieser Überschrift">¶</a></h2>
<p>Mit Hilfe des Where-Objectes können die Objekte der Pipeline gefiltert werden.</p>
<div class="highlight-sh"><div class="highlight"><pre>PS C:<span class="se">\&gt;</span> Get-Service | Where-Object <span class="o">{</span> <span class="nv">$_</span>.Status -eq <span class="s2">&quot;Running&quot;</span> <span class="o">}</span> | more

Status   Name               DisplayName
------   ----               -----------
Running  AntiVirSchedule... Avira AntiVir Planer
Running  AntiVirService     Avira AntiVir Guard
Running  AppHostSvc         Anwendungshost-Hilfsdienst
Running  Apple Mobile De... Apple Mobile Device
Running  AudioEndpointBu... Windows-Audio-Endpunkterstellung
Running  Audiosrv           Windows-Audio
Running  AVerRemote         AVerRemote
Running  BFE                Basisfiltermodul
Running  BITS               Intelligenter HintergrundÃƒÆ’Ã†â€™Ãƒâ€šÃ‚Â¼bertragun...
Running  Bonjour Service    Dienst <span class="s2">&quot;Bonjour&quot;</span>
Running  Browser            Computerbrowser
Running  CertPropSvc        Zertifikatverteilung
</pre></div>
</div>
<p id="index-12">Das Cmdlet erwartet, dass man in geschweiften Klammern einen Powershell-Befehl übergibt. Das jeweils zu untersuchende Objekt kann über die Variable $_ angesprochen werden. Die Eigenschaft Status wird dann auf den Wert Running verglichen. Nur wenn dieses Objekt den entsprechenden Wert hat, wird es in die Pipeline gelassen.</p>
<p>Damit entspricht das Where-Objekt im Grunde der Formulierung einer Bedingung, die TRUE ergeben muss.</p>
<div class="highlight-sh"><div class="highlight"><pre>Get-WmiObject Win32_Service | ? <span class="o">{(</span><span class="nv">$_</span>.Started -eq <span class="nv">$false</span><span class="o">)</span> -and <span class="o">(</span><span class="nv">$_</span>.StartMode -eq <span class="s2">&quot;Auto&quot;</span><span class="o">)}</span> | Format-Table
</pre></div>
</div>
<img alt="_images/pipeline_where.jpg" src="_images/pipeline_where.jpg" />
<p>Das gleiche Ergebnis hätte man auch ohne Where-Objekt erhalten können, indem man WMI mit den korrekten Fragen füttert.</p>
<div class="highlight-sh"><div class="highlight"><pre>Get-WmiObject -query <span class="s2">&quot;select * from win32_Service where Started=false and StartMode=&#39;Auto&#39;&quot;</span> | Format-Table
</pre></div>
</div>
<img alt="_images/pipeline_wmi_ohne_where.jpg" src="_images/pipeline_wmi_ohne_where.jpg" />
<div class="section" id="begrenzen-der-anzahl-der-ausgabe">
<span id="index-13"></span><h3>11.5.1. Begrenzen der Anzahl der Ausgabe<a class="headerlink" href="#begrenzen-der-anzahl-der-ausgabe" title="Permalink zu dieser Überschrift">¶</a></h3>
<p>Select-Object kann neben der Ausgabe bestimmter Eigenschaften auch die Anzahl der ausgegebenen Datensätze begrenzen</p>
<div class="highlight-sh"><div class="highlight"><pre><span class="c"># List the five largest files in a directory:</span>
Dir | Sort-Object Length -descending |  Select-Object -first 5

<span class="c"># List the five longest-running processes:</span>
Get-Process | Sort-Object StartTime | Select-Object -last 5 | Format-Table ProcessName, StartTime

<span class="c"># Alias shortcuts make the line shorter but also harder to read:</span>
gps | sort StartTime -ea SilentlyContinue | <span class="k">select</span> -last 5 | ft ProcessName, StartTime
</pre></div>
</div>
</div>
</div>
<div class="section" id="foreach-objekt">
<span id="index-14"></span><h2>11.6. Foreach-Objekt<a class="headerlink" href="#foreach-objekt" title="Permalink zu dieser Überschrift">¶</a></h2>
<p>Anstelle auf die Ergebnisse einer Pipeline zu warten, kann mit Hilfe des Foreach-Object-Cmdlets sofort auf jedes einzelne Objekt zugegriffen werden. Foreach-Object erwartet in geschweiften Klammern eine Anweisung, was es mit dem jeweiligen Objekt anstellen soll.</p>
<p id="index-15">Foreach-Object kann wie das Where-Object als Filter verwendet werden. Dazu muss nur in der geschweiften Klammer eine Bedingung formuliert werden. Das Where-Object hat man eigentlich nur aus Beguemlichkeit geschaffen. Die folgenden Befehle haben alle das gleiche Ergebnis.</p>
<div class="highlight-sh"><div class="highlight"><pre>Get-Service | Where-Object <span class="o">{</span> <span class="nv">$_</span>.Status -eq <span class="s2">&quot;Running&quot;</span> <span class="o">}</span>
Get-Service | ? <span class="o">{</span> <span class="nv">$_</span>.Status -eq <span class="s2">&quot;Running&quot;</span> <span class="o">}</span>
Get-Service | ForEach-Object <span class="o">{</span> <span class="k">if</span> <span class="o">(</span><span class="nv">$_</span>.Status -eq <span class="s2">&quot;Running&quot;</span><span class="o">)</span> <span class="o">{</span> <span class="nv">$_</span> <span class="o">}</span> <span class="o">}</span>
Get-Service | % <span class="o">{</span> <span class="k">if</span> <span class="o">(</span><span class="nv">$_</span>.Status  -eq <span class="s2">&quot;Running&quot;</span><span class="o">)</span> <span class="o">{</span> <span class="nv">$_</span> <span class="o">}</span> <span class="o">}</span>
</pre></div>
</div>
<div class="admonition note">
<p class="first admonition-title">Bemerkung</p>
<p>ForEach-Object actually executes three script blocks, not just one. If you specify only one script block in braces after ForEach-Object, it will be executed once for every pipeline object. If you specify two script blocks, the first will be executed once and before the first pipeline object. If you specify three script blocks, the last will be executed once after the last pipeline object. The following will help you carry out initialization and tidying tasks or simply output initial and ending messages:</p>
<div class="highlight-sh"><div class="highlight"><pre>Get-Service | ForEach-Object <span class="o">{</span><span class="s2">&quot;Running services:&quot;</span><span class="o">}{</span> <span class="k">if</span> <span class="o">(</span><span class="nv">$_</span>.Status -eq <span class="s2">&quot;Running&quot;</span><span class="o">)</span> <span class="o">{</span> <span class="nv">$_</span> <span class="o">}</span> <span class="o">}{</span><span class="s2">&quot;Done.&quot;</span><span class="o">}</span>
</pre></div>
</div>
<p class="last">The three script blocks of ForEach-Object actually correspond to the three script blocks begin, process, and end, which you&#8217;ll examine in more detail
later</p>
</div>
<div class="sidebar">
<p class="first sidebar-title">Tafelbild</p>
<p class="last">Übersetzen Sie den englischen Text</p>
</div>
<a class="reference external image-reference" href="_images/notizzettel.png"><img alt="alternate text" class="align-left" src="_images/notizzettel.png" style="width: 50px;" /></a>
</div>
<div class="section" id="zwischenergebnisse">
<h2>11.7. Zwischenergebnisse<a class="headerlink" href="#zwischenergebnisse" title="Permalink zu dieser Überschrift">¶</a></h2>
<p id="index-16">Während einer Pipeline-Operation können mit Hilfe des Tee-Objektes die Zustände von Pipeline-Operationen in Variablen zwischengespeichert werden.</p>
<div class="highlight-sh"><div class="highlight"><pre>Get-Process | Tee-Object -variable a1 | Select-Object Name, Description <span class="sb">`</span> |
Tee-Object -variable a2 | Sort-Object Name <span class="sb">`</span>

<span class="nv">$a1</span>
<span class="nv">$a2</span>
</pre></div>
</div>
</div>
<div class="section" id="ausgabe-von-pipeline-ergebnissen">
<h2>11.8. Ausgabe von Pipeline-Ergebnissen<a class="headerlink" href="#ausgabe-von-pipeline-ergebnissen" title="Permalink zu dieser Überschrift">¶</a></h2>
</div>
<div class="section" id="funktionen-und-pipeline">
<h2>11.9. Funktionen und Pipeline<a class="headerlink" href="#funktionen-und-pipeline" title="Permalink zu dieser Überschrift">¶</a></h2>
</div>
<div class="section" id="pipeline-oder-schleife">
<h2>11.10. Pipeline oder Schleife<a class="headerlink" href="#pipeline-oder-schleife" title="Permalink zu dieser Überschrift">¶</a></h2>
<p>Häufig ist ein Problem sowohl mit Hilfe der Pipeline als auch mit Hilfe der &#8220;normalen&#8221; strukturierten Programmierung möglich. Je nach Szenario kann es allerdings zu erheblichen Geschwindigkeitsunterschieden kommen. Folgendes Beispiel verdeutlicht den Zusammenhang.</p>
<div class="highlight-sh"><div class="highlight"><pre><span class="c">#eine strukturierte Herangehensweise an das Problem</span>
<span class="c">#Schleife mit if</span>
<span class="c">#3 Minuten, 18 sec</span>
<span class="c">#$zeit = Get-Date</span>
<span class="c">#$result = Get-Content $env:windir\Windowsupdate.log</span>
<span class="c">#foreach($zeile in $result)</span>
<span class="c">#{</span>
<span class="c">#       if($zeile.Contains(&quot;WARNING&quot;))</span>
<span class="c">#       {</span>
<span class="c">#               $line = $zeile.Split(&quot;`t&quot;)</span>
<span class="c">#               Write-Host ($line[0] + &quot; &quot; +  $line[1])</span>
<span class="c">#               #Add-Content -Path &quot;C:\ergebnisnew.txt&quot; -value $zeile;</span>
<span class="c">#       }</span>
<span class="c">#}</span>
<span class="c">#$diff = $zeit - (Get-Date)</span>

<span class="c">#Write-Host $diff</span>


<span class="c">#Das gleiche nun mit Pipes</span>
<span class="c">#dauert 5 Min, 48 sec !!!</span>
<span class="c">#$zeit = Get-Date</span>

<span class="c">#Get-Content $Env:windir\WindowsUpdate.log | Select-String &quot;WARNING&quot; | Add-Content &quot;C:\Ergebnis3.txt&quot;</span>
<span class="c">#$diff = $zeit - (Get-Date)</span>


<span class="c">#auch mit Pipes kann es schneller gehen</span>

<span class="c">#Write-Host $diff</span>
<span class="nv">$zeit</span> <span class="o">=</span> Get-Date
Get-Content <span class="nv">$Env</span>:windir<span class="se">\W</span>indowsUpdate.log -readCount 1000 | Select-String <span class="s2">&quot;WARNING&quot;</span> | Add-Content <span class="s2">&quot;C:\Ergebnis3.txt&quot;</span>
<span class="nv">$diff</span> <span class="o">=</span> <span class="nv">$zeit</span> - <span class="o">(</span>Get-Date<span class="o">)</span>
Write-Host <span class="nv">$diff</span> <span class="sb">`</span>
</pre></div>
</div>
</div>
<div class="section" id="pipeline-filter-und-funktionen">
<h2>11.11. Pipeline/Filter und Funktionen<a class="headerlink" href="#pipeline-filter-und-funktionen" title="Permalink zu dieser Überschrift">¶</a></h2>
<p>Funktionen können die Ergebnisse der Pipeline weiterverarbeiten. Es stellt sich lediglich die Frage, ob dies im langsamen <em>sequentiellen</em> oder schnelleren <em>streaming</em>-Modus vonstatten geht.</p>
<div class="section" id="sequentieller-modus">
<h3>11.11.1. Sequentieller Modus<a class="headerlink" href="#sequentieller-modus" title="Permalink zu dieser Überschrift">¶</a></h3>
<p>Im einfachsten Falle unterstützt eine Funktion nicht wirklich die Pipeline. Die Ergebnisse der Pipeline stehen in der automatischen Variable <strong>$input</strong> zur Verfügung. Im einfachsten Falle gibt die Funktion einfach die Inhalte von $input aus.</p>
<div class="highlight-sh"><div class="highlight"><pre>Function output
<span class="o">{</span>
        <span class="nv">$input</span>
<span class="o">}</span>
<span class="c"># The function, when invoked alone,</span>
<span class="c"># will return nothing because no pipeline</span>
<span class="c"># results are available:</span>
output
<span class="c"># If you create an array in the pipeline,</span>
<span class="c"># the function will output the array:</span>
1,2,3 | output
1
2
3

<span class="c"># The function is completely indifferent to</span>
<span class="c"># which type of data is in the pipeline:</span>
Dir | output
</pre></div>
</div>
<p>Die Funktion soll nun aber abgeändert werden; alle Dateien mit der Endung .exe sollen in roter Farbe ausgegeben werden.</p>
<div class="highlight-sh"><div class="highlight"><pre><span class="k">function </span>MarkEXE
<span class="o">{</span>
   <span class="c"># Note old foreground color</span>
   <span class="nv">$oldcolor</span> <span class="o">=</span> <span class="nv">$host</span>.ui.rawui.ForegroundColor
   <span class="c"># Inspect each pipeline element separately in a loop</span>
   Foreach <span class="o">(</span><span class="nv">$element</span> in <span class="nv">$input</span><span class="o">)</span> <span class="o">{</span>
        <span class="c"># If the name ends in &quot;.exe&quot;, change the foreground color to red:</span>
        If <span class="o">(</span><span class="nv">$element</span>.name.toLower<span class="o">()</span>.endsWith<span class="o">(</span><span class="s2">&quot;.exe&quot;</span><span class="o">))</span> <span class="o">{</span>
           <span class="nv">$host</span>.ui.Rawui.ForegroundColor <span class="o">=</span> <span class="s2">&quot;red&quot;</span>
        <span class="o">}</span>
        Else <span class="o">{</span>
           <span class="c"># Otherwise, use the normal foreground color:</span>
           <span class="nv">$host</span>.ui.Rawui.ForegroundColor <span class="o">=</span> <span class="nv">$oldcolor</span>
        <span class="o">}</span>
        <span class="c"># Output element</span>
        <span class="nv">$element</span>
  <span class="o">}</span>
  <span class="c"># Finally, restore the old foreground color:</span>
  <span class="nv">$host</span>.ui.Rawui.ForegroundColor <span class="o">=</span> <span class="nv">$oldcolor</span>
<span class="o">}</span>

Measure-Command <span class="o">{</span>Dir <span class="s2">&quot;c:\program files&quot;</span> -recurse | MarkEXE <span class="o">}</span>

PS C:<span class="se">\W</span>indows<span class="se">\s</span>ystem32&gt; Measure-Command <span class="o">{</span>Dir <span class="s2">&quot;c:\program files&quot;</span> <span class="sb">`</span> -recurse | MarkEXE <span class="o">}</span> <span class="sb">`</span>

Days              : 0
Hours             : 0
Minutes           : 0
Seconds           : 0
Milliseconds      : 706
..
</pre></div>
</div>
<p>Die Ausführung des Skripts dauert 706 msec.</p>
</div>
<div class="section" id="filter">
<h3>11.11.2. Filter<a class="headerlink" href="#filter" title="Permalink zu dieser Überschrift">¶</a></h3>
<p>Ersetzt man aber das Schlüsselwort <strong>Function</strong> durch das Wort <strong>Filter</strong>, dann ist die Ausgabe ca. um den Faktor 3 schneller.</p>
<div class="highlight-sh"><div class="highlight"><pre>PS C:<span class="se">\W</span>indows<span class="se">\s</span>ystem32&gt; Measure-Command <span class="o">{</span>Dir <span class="s2">&quot;c:\program files&quot;</span> <span class="sb">`</span> -recurse | MarkEXEFilter <span class="o">}</span> <span class="sb">`</span>

Days              : 0
Hours             : 0
Minutes           : 0
Seconds           : 0
Milliseconds      : 189
..
</pre></div>
</div>
<p>Da die $input-Variable für Filter immer nur aus einem Wert besteht, macht ihr Einsatz innerhalb der Schleife wenig Sinn. Man kann Sie besser durch die Variable $_ ersetzen.</p>
<div class="highlight-sh"><div class="highlight"><pre>Filter MarkEXEFilter2 <span class="o">{</span>
    <span class="c"># Note old foreground color</span>
    <span class="nv">$oldcolor</span> <span class="o">=</span> <span class="nv">$host</span>.ui.rawui.ForegroundColor
    <span class="c"># The current pipeline element is in $_</span>
    <span class="c"># If the name ends in &quot;.exe&quot;, change</span>
    <span class="c"># the foreground color to red:</span>
    If <span class="o">(</span><span class="nv">$_</span>.name.toLower<span class="o">()</span>.endsWith<span class="o">(</span><span class="s2">&quot;.exe&quot;</span><span class="o">))</span>
    <span class="o">{</span>
        <span class="nv">$host</span>.ui.Rawui.ForegroundColor <span class="o">=</span> <span class="s2">&quot;red&quot;</span>
    <span class="o">}</span>
    Else
    <span class="o">{</span>
        <span class="c"># Otherwise, use the normal foreground color:</span>
        <span class="nv">$host</span>.ui.Rawui.ForegroundColor <span class="o">=</span> <span class="nv">$oldcolor</span>
    <span class="o">}</span>
    <span class="c"># Output element</span>
    <span class="nv">$_</span>
    <span class="c"># Finally, restore the old foreground color:</span>
    <span class="nv">$host</span>.ui.Rawui.ForegroundColor <span class="o">=</span> <span class="nv">$oldcolor</span>
<span class="o">}</span>


PS C:<span class="se">\W</span>indows<span class="se">\s</span>ystem32&gt; Measure-Command <span class="o">{</span>Dir <span class="s2">&quot;c:\program files&quot;</span> <span class="sb">`</span> -recurse | MarkEXEFilter2 <span class="o">}</span> <span class="sb">`</span>


Days              : 0
Hours             : 0
Minutes           : 0
Seconds           : 1
Milliseconds      : 77
..
</pre></div>
</div>
</div>
<div class="section" id="generische-filter">
<h3>11.11.3. Generische Filter<a class="headerlink" href="#generische-filter" title="Permalink zu dieser Überschrift">¶</a></h3>
<p>Filter sind beim Einsatz von Pipelines den Funktionen vorzuziehen, weil Sie die Ergebnisse der Pipeline sofort verarbeiten können. Nachteilig kann sich aber auswirken, dass alle Codeblöcke eines Filters immer wieder aufgerufen werden.</p>
<p>In unserem Beispiel wird immer die alte Vordergrundfarbe gespeichert und nach dem Durchlauf wieder zurückgesetzt. Dies ist zeit- und ressourcenintensiv.</p>
<p>Das Verhalten einer Funktion kann aber an diese Situation agepasst werden, indem man innerhalb einer Funktion spezielle Bereiche definiert.</p>
<ul class="simple">
<li>begin: (Initialisierung: Wird einmal beim Beginn aufgerufen)</li>
<li>process:</li>
<li>end: Aufräumen; wird einmal am Ende aufgerufen</li>
</ul>
<p>Ein Filter ist für die Powershell nichts anderes als eine Funktion mit einem einzigen <strong>process</strong>-Block.</p>
<p>Die optimale Codierung des obigen Problems lagert deswegen das Speichern und Zurücksetzen der Farbein in den begin- bzw. end-Block aus</p>
<div class="highlight-sh"><div class="highlight"><pre>Function MarkEXE <span class="o">{</span>
  begin <span class="o">{</span>
     <span class="c"># Note old foreground color</span>
     <span class="nv">$oldcolor</span> <span class="o">=</span> <span class="nv">$host</span>.ui.rawui.ForegroundColor
  <span class="o">}</span>

  process <span class="o">{</span>
    If <span class="o">(</span><span class="nv">$_</span>.name.toLower<span class="o">()</span>.endsWith<span class="o">(</span><span class="s2">&quot;.exe&quot;</span><span class="o">))</span> <span class="o">{</span>
        <span class="nv">$host</span>.ui.Rawui.ForegroundColor <span class="o">=</span> <span class="s2">&quot;red&quot;</span>
    <span class="o">}</span>
    Else
    <span class="o">{</span>
        <span class="nv">$host</span>.ui.Rawui.ForegroundColor <span class="o">=</span> <span class="nv">$oldcolor</span>
    <span class="o">}</span>
    <span class="c"># Output element</span>
    <span class="nv">$_</span>
  <span class="o">}</span>

  end <span class="o">{</span>
     <span class="c"># Finally, restore the old foreground color:</span>
     <span class="nv">$host</span>.ui.Rawui.ForegroundColor <span class="o">=</span> <span class="nv">$oldcolor</span>
  <span class="o">}</span>
<span class="o">}</span>
</pre></div>
</div>
<div class="admonition note">
<p class="first admonition-title">Bemerkung</p>
<p>Das nächste Beispiel zeigt, dass ein Filter in Wirklichkeit eine normale Funktion mit einem process-Block ist.</p>
<div class="highlight-sh"><pre>filter Test { "Output: " + $_ }

Let's look now at the definition of the filter:
$function:Test
process {
"Output: " + $_
}</pre>
</div>
<p class="last">PowerShell hat die Filter-Anweisung in eine normale Funktion umgewandelt und den Code in einen process-Block gesetzt.</p>
</div>
</div>
</div>
<div class="section" id="zusammenfassung">
<h2>11.12. Zusammenfassung<a class="headerlink" href="#zusammenfassung" title="Permalink zu dieser Überschrift">¶</a></h2>
<p>PowerShell uses a pipeline for all command entries, which feeds the results of the preceding command directly into the subsequent command. The pipeline is active even when you enter only a single command because PowerShell always automatically adds the Out-Default cmdlet at the pipeline&#8217;s end so that it always results in a two-member instruction chain.</p>
<p>Single command results are passed as objects. The cmdlets shown in Table 5.1 can filter, sort, compare, measure, expand, and restrict pipeline elements. All cmdlets accomplish this on the basis of object properties. In the process, the pipeline distinguishes between sequential and streaming modes. In streaming mode, command results are each collected, and then passed in mass onto the
next command. Which mode you use depends solely on the pipeline commands used.</p>
<p>Output cmdlets dispose of output. If you specify none, PowerShell automatically uses Out-Host to output the results in the console. However, you could just as well send results to a file or printer. All output cmdlets convert objects into readable text while formatting cmdlets are responsible for conversion.</p>
<p>In addition to traditional output cmdlets, export cmdlets store objects either as comma-separated lists that can be opened in Excel or serialized in an XML format. Serialized objects can be comfortably converted back into objects at a later time. Because when exporting, in contrast to outputting, only plain object properties, without cosmetic formatting, are stored so that no formatting cmdlets are used.</p>
</div>
<div class="section" id="links">
<h2>11.13. Links<a class="headerlink" href="#links" title="Permalink zu dieser Überschrift">¶</a></h2>
<p><a class="reference external" href="http://thepowershellguy.com/blogs/posh/archive/2007/01/21/powershell-gui-scripblock-monitor-script.aspx">http://thepowershellguy.com/blogs/posh/archive/2007/01/21/powershell-gui-scripblock-monitor-script.aspx</a></p>
<div class="admonition note">
<p class="first admonition-title">Bemerkung</p>
<p>Als Beispiel für begin-process-end sowie pipeline kann man im nächsten Jahr eine Datenbankverbindung nehmen. Die Ergebnisse des dir-Befehls sollen in eine Datenbank geschrieben werden.</p>
<p>begin &#8212; öffnet die Verbindung
process &#8211; führt die insert-Statements aus
end &#8211; schließt die Datenbankverbindung nach dem letzten insert</p>
<p class="last">a la : Dir  -recurse | insertFileInDatabase</p>
</div>
</div>
</div>


          </div>
        </div>
      </div>
      <div class="clearer"></div>
    </div>
    <div class="related">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="genindex.html" title="Allgemeiner Index"
             >Index</a></li>
        <li class="right" >
          <a href="powershell_customobjects.html" title="12. Objekte in der PS"
             >weiter</a> |</li>
        <li class="right" >
          <a href="powershell_funktionen.html" title="10. Funktionen"
             >zurück</a> |</li>
        <li><a href="index.html">PS4SYS</a> &raquo;</li> 
      </ul>
    </div>
    <div class="footer">
        &copy; Copyright 2010, STE.
      Mit <a href="http://sphinx-doc.org/">Sphinx</a> 1.2b1 erstellt.
    </div>
  </body>
</html>